home *** CD-ROM | disk | FTP | other *** search
/ The CICA Windows Explosion! / The CICA Windows Explosion! - Disc 2.iso / programr / tkern10.zip / GNUISH\PATCHES < prev    next >
Text File  |  1990-09-19  |  25KB  |  746 lines
  1. diff -c DOS/error.c GNU/error.c
  2. *** DOS/error.c    Thu Sep 20 00:19:04 1990
  3. --- GNU/error.c    Thu Sep 20 00:19:48 1990
  4. ***************
  5. *** 45,55 ****
  6.   #else
  7.   void exit ();
  8.   
  9. - #ifdef MSDOS
  10. - /* Force consistency of the prototypes.  */
  11. - #include <gnulib.h>
  12. - #endif
  13. - 
  14.   static char *
  15.   strerror (errnum)
  16.        int errnum;
  17. --- 45,50 ----
  18. diff -c DOS/getopt.c GNU/getopt.c
  19. *** DOS/getopt.c    Thu Sep 20 00:19:02 1990
  20. --- GNU/getopt.c    Thu Sep 20 00:19:40 1990
  21. ***************
  22. *** 14,26 ****
  23.      You should have received a copy of the GNU General Public License
  24.      along with this program; if not, write to the Free Software
  25.      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  26. - 
  27. - /* MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  28. -    This port is distributed under the terms of the GNU General
  29. -    Public License as published by the Free Software Foundation.
  30. - 
  31. -    $Header: e:/gnu/lib/RCS/getopt.c 1.1.0.1 90/09/11 09:46:00 tho Exp $
  32. -  */
  33.   
  34.   #ifdef __STDC__
  35.   #define CONST const
  36. --- 14,19 ----
  37. ***************
  38. *** 51,62 ****
  39.   #ifdef sparc
  40.   #include <alloca.h>
  41.   #else
  42. - #ifdef MSDOS
  43. - #include <malloc.h>
  44. - #else
  45.   char *alloca ();
  46.   #endif
  47. - #endif
  48.   #endif /* not __GNUC__ */
  49.   
  50.   #if defined(STDC_HEADERS) || defined(__GNU_LIBRARY__)
  51. --- 44,51 ----
  52. ***************
  53. *** 79,91 ****
  54.   char *malloc ();
  55.   #endif
  56.   
  57. - #ifdef MSDOS
  58. - /* Include the <getopt.h> header file to insure consistency
  59. -    of the prototypes.  */
  60. - #include <getopt.h>
  61. - static void exchange (char **argv);
  62. - #endif /* MSDOS */
  63. - 
  64.   /* For communication from `getopt' to the caller.
  65.      When `getopt' finds an option that takes an argument,
  66.      the argument value is returned here.
  67. --- 68,73 ----
  68. ***************
  69. *** 156,166 ****
  70.     REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
  71.   } ordering;
  72.   
  73. - 
  74. - /* We have included <getopt.h>, so we'd better not redefine
  75. -    struct option.  */
  76. - #ifndef MSDOS
  77. - 
  78.   /* Describe the long-named options requested by the application.
  79.      _GETOPT_LONG_OPTIONS is a vector of `struct option' terminated by an
  80.      element containing a name which is zero.
  81. --- 138,143 ----
  82. ***************
  83. *** 174,180 ****
  84.     int *flag;
  85.     int val;
  86.   };
  87. - #endif /* not MSDOS */
  88.   
  89.   CONST struct option *_getopt_long_options;
  90.   
  91. --- 151,156 ----
  92. diff -c DOS/glob.c GNU/glob.c
  93. *** DOS/glob.c    Thu Sep 20 00:19:06 1990
  94. --- GNU/glob.c    Thu Sep 20 00:19:52 1990
  95. ***************
  96. *** 14,26 ****
  97.      You should have received a copy of the GNU General Public License
  98.      along with this program; if not, write to the Free Software
  99.      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  100. - 
  101. - /* MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  102. -    This port is distributed under the terms of the GNU General
  103. -    Public License as published by the Free Software Foundation.
  104. - 
  105. -    $Header: e:/gnu/lib/RCS/glob.c 1.0.0.3 90/09/19 22:50:58 tho Exp $
  106. -  */
  107.   
  108.   /* To whomever it may concern: I have never seen the code which most
  109.      Unix programs use to perform this function.  I wrote this from scratch
  110. --- 14,19 ----
  111. ***************
  112. *** 79,99 ****
  113.   #ifdef sparc
  114.   #include <alloca.h>
  115.   #else /* Not sparc.  */
  116. - #ifdef MSDOS
  117. - #include <malloc.h>
  118. - #else
  119.   extern char *alloca ();
  120. - #endif
  121.   #endif /* sparc.  */
  122.   #endif /* GCC.  */
  123.   
  124. - #ifdef MSDOS
  125. - #include <gnulib.h>
  126. - static  int glob_match_after_star(char *,char *);
  127. - static  char * *glob_dir_to_array(char *,char **);
  128. - #endif /* MSDOS */
  129. -   
  130. - 
  131.   /* Nonzero if '*' and '?' do not match an initial '.' for glob_filename.  */
  132.   int noglob_dot_filenames = 1;
  133.   
  134. --- 72,81 ----
  135. ***************
  136. *** 331,342 ****
  137.         dp = readdir (d);
  138.         if (dp == NULL)
  139.       break;
  140. - #ifdef MSDOS    /* dp->d_ino is always 0 in the MS-DOS implementation. */
  141. -       if (glob_match (pat, dp->d_name, noglob_dot_filenames))
  142. - #else
  143.         if (dp->d_ino != 0
  144.         && glob_match (pat, dp->d_name, noglob_dot_filenames))
  145. - #endif /* MSDOS */
  146.       {
  147.         nextlink = (struct globval *) alloca (sizeof (struct globval));
  148.         nextlink->next = lastlink;
  149. --- 313,320 ----
  150. ***************
  151. *** 570,579 ****
  152.   }
  153.   
  154.   #ifdef TEST
  155. - 
  156. - #ifdef MSDOS
  157. - #include <stdio.h>
  158. - #endif
  159.   
  160.   main (argc, argv)
  161.        int argc;
  162. --- 548,553 ----
  163. diff -c DOS/regex.c GNU/regex.c
  164. *** DOS/regex.c    Thu Sep 20 00:19:32 1990
  165. --- GNU/regex.c    Thu Sep 20 00:20:06 1990
  166. ***************
  167. *** 15,27 ****
  168.      along with this program; if not, write to the Free Software
  169.      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  170.   
  171. - /* MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  172. -    This port is distributed under the terms of the GNU General
  173. -    Public License as published by the Free Software Foundation.  */
  174.   
  175. - static char RCSid[] =
  176. -    "$Header: e:/gnu/lib/RCS/regex.c 1.1.0.1 90/09/11 09:24:43 tho Exp $";
  177. - 
  178.   /* To test, compile with -Dtest.  This Dtestable feature turns this into
  179.      a self-contained program which reads a pattern, describes how it
  180.      compiles, then reads a string and searches for it.
  181. --- 15,21 ----
  182. ***************
  183. *** 58,122 ****
  184.   char *realloc ();
  185.   #endif
  186.   
  187. - 
  188. - #ifdef MSDOS
  189. - 
  190. - /* At the moment these macros are used for shutting up the compiler, but
  191. -    one day we might support really 'huge' regular expressions.
  192. -    Also we should check for wrap-arounds in the near models.  */
  193. - 
  194. - #if defined (_MSC_VER) && (_MSC_VER >= 600)
  195. - #define HUGE _huge
  196. - #else /* _MSC_VER < 600 */
  197. - #define HUGE huge
  198. - #endif /* _MSC_VER < 600 */
  199. - 
  200. - #if defined (M_I86CM) || defined (M_I86LM) 
  201. - #define PTR_DIFF(ptr1,ptr2) \
  202. -   ((long)((char HUGE *)(ptr1) - (char HUGE *)(ptr2)))
  203. - #else
  204. - /* After changing ALLOCATED to size_t for the small and medium model,
  205. -    we could remove the cast to long.  */
  206. - #define PTR_DIFF(ptr1,ptr2)    ((long)((ptr1) - (ptr2)))
  207. - #endif
  208. - 
  209. - /* The second argument to xrealloc:  */
  210. - #define SIZE_T size_t
  211. - 
  212. - /* The 80[12]?86 are always in danger of stack overflow.  So better check
  213. -    the success of each alloca ().  */
  214. - #define TEST_ALLOCA(ptr) \
  215. -   if (ptr==NULL)                              \
  216. -     {                                      \
  217. -       fprintf (stderr, "Stack overflow: %s, l.%d\n", __FILE__, __LINE__); \
  218. -       abort ();                                  \
  219. -     }
  220. - 
  221. - #else /* not MSDOS */
  222. - 
  223. - #define PTR_DIFF(ptr1,ptr2)    ((ptr1) - (ptr2))
  224. - #define SIZE_T int
  225. - #define TEST_ALLOCA(ptr)
  226. - 
  227. - #endif /* not MSDOS */
  228. - 
  229. - 
  230. - #ifdef MSDOS
  231. - /* Since  sizeof (int) != sizeof (void *) in the compact and large models,
  232. -    we'd better provide prototypes.  */
  233. - static    int bcmp_translate (unsigned char *s1, unsigned char *s2, int len,
  234. -                 unsigned char *translate);
  235. - static    void init_syntax_once (void);
  236. - static    void insert_jump (char op, char *from, char *to, char *current_end);
  237. - static    void insert_jump_n (char op, char *from, char *to, char *current_end,
  238. -                 unsigned int n);
  239. - static    void insert_op_2 (char op, char *there, char *current_end, int num_1,
  240. -               int num_2);
  241. - static    void store_jump (char *from, char opcode, char *to);
  242. - static    void store_jump_n (char *from, char opcode, char *to, unsigned int n);
  243. - #endif /* MSDOS */
  244. - 
  245. - 
  246.   /* Make alloca work the best possible way.  */
  247.   #ifdef __GNUC__
  248.   #define alloca __builtin_alloca
  249. --- 52,57 ----
  250. ***************
  251. *** 124,136 ****
  252.   #ifdef sparc
  253.   #include <alloca.h>
  254.   #else
  255. - #ifdef MSDOS
  256. - #include <malloc.h>
  257. - #else
  258.   char *alloca ();
  259.   #endif
  260.   #endif
  261. - #endif
  262.   
  263.   
  264.   /* Define the syntax stuff, so we can do the \<, \>, etc.  */
  265. --- 59,67 ----
  266. ***************
  267. *** 291,305 ****
  268.    
  269.   
  270.   /* Store NUMBER in two contiguous bytes starting at DESTINATION.  */
  271. - #ifdef MSDOS            /* This is to shut up the compiler.  */
  272. - #define STORE_NUMBER(destination, number)                \
  273. -   { (destination)[0] = (char) ((number) & 0377);            \
  274. -     (destination)[1] = (char) ((number) >> 8); }
  275. - #else /* not MSDOS */
  276.   #define STORE_NUMBER(destination, number)                \
  277.     { (destination)[0] = (number) & 0377;                    \
  278.       (destination)[1] = (number) >> 8; }
  279. - #endif /* not MSDOS */
  280.     
  281.   /* Same as STORE_NUMBER, except increment the destination pointer to
  282.      the byte after where the number is stored.  Watch out that values for
  283. --- 222,230 ----
  284. ***************
  285. *** 330,340 ****
  286.      The argument SYNTAX is a bit-mask comprised of the various bits
  287.      defined in regex.h.  */
  288.   
  289. ! LONG
  290.   re_set_syntax (syntax)
  291. !   LONG syntax;
  292.   {
  293. !   LONG ret;
  294.   
  295.     ret = obscure_syntax;
  296.     obscure_syntax = syntax;
  297. --- 255,265 ----
  298.      The argument SYNTAX is a bit-mask comprised of the various bits
  299.      defined in regex.h.  */
  300.   
  301. ! int
  302.   re_set_syntax (syntax)
  303. !   int syntax;
  304.   {
  305. !   int ret;
  306.   
  307.     ret = obscure_syntax;
  308.     obscure_syntax = syntax;
  309. ***************
  310. *** 342,348 ****
  311.   }
  312.   
  313.   /* Set by re_set_syntax to the current regexp syntax to recognize.  */
  314. ! LONG obscure_syntax = 0;
  315.   
  316.   
  317.   
  318. --- 267,273 ----
  319.   }
  320.   
  321.   /* Set by re_set_syntax to the current regexp syntax to recognize.  */
  322. ! int obscure_syntax = 0;
  323.   
  324.   
  325.   
  326. ***************
  327. *** 372,378 ****
  328.   /* Make sure we have at least N more bytes of space in buffer.  */
  329.   #define GET_BUFFER_SPACE(n)                        \
  330.     {                                        \
  331. !     while (PTR_DIFF (b, bufp->buffer) + (n) >= bufp->allocated)        \
  332.         EXTEND_BUFFER;                            \
  333.     }
  334.   
  335. --- 297,303 ----
  336.   /* Make sure we have at least N more bytes of space in buffer.  */
  337.   #define GET_BUFFER_SPACE(n)                        \
  338.     {                                        \
  339. !     while (b - bufp->buffer + (n) >= bufp->allocated)            \
  340.         EXTEND_BUFFER;                            \
  341.     }
  342.   
  343. ***************
  344. *** 382,397 ****
  345.       GET_BUFFER_SPACE (1);                        \
  346.       *b++ = (char) (ch);                            \
  347.     }
  348. ! 
  349. ! #ifdef MSDOS
  350. ! /* We could (if we payed more attention to signed/unsigned issues)
  351. !    increase MAX_ALLOC to (1L<<15).  But we will do only *after* we've
  352. !    actually hit this limit!  */
  353. ! #define MAX_ALLOC    (1L<<14)
  354. ! #else /* not MSDOS */
  355. ! #define MAX_ALLOC    (1L<<16)
  356. ! #endif /* not MSDOS */
  357. ! 
  358.   /* Extend the buffer by twice its current size via reallociation and
  359.      reset the pointers that pointed into the old allocation to point to
  360.      the correct places in the new allocation.  If extending the buffer
  361. --- 307,313 ----
  362.       GET_BUFFER_SPACE (1);                        \
  363.       *b++ = (char) (ch);                            \
  364.     }
  365. !   
  366.   /* Extend the buffer by twice its current size via reallociation and
  367.      reset the pointers that pointed into the old allocation to point to
  368.      the correct places in the new allocation.  If extending the buffer
  369. ***************
  370. *** 398,407 ****
  371.      results in it being larger than 1 << 16, then flag memory exhausted.  */
  372.   #define EXTEND_BUFFER                            \
  373.     { char *old_buffer = bufp->buffer;                    \
  374. !     if (bufp->allocated == MAX_ALLOC) goto too_big;            \
  375.       bufp->allocated *= 2;                        \
  376. !     if (bufp->allocated > MAX_ALLOC) bufp->allocated = MAX_ALLOC;    \
  377. !     bufp->buffer = (char *) realloc (bufp->buffer, (SIZE_T) bufp->allocated); \
  378.       if (bufp->buffer == 0)                        \
  379.         goto memory_exhausted;                        \
  380.       b = (b - old_buffer) + bufp->buffer;                \
  381. --- 314,323 ----
  382.      results in it being larger than 1 << 16, then flag memory exhausted.  */
  383.   #define EXTEND_BUFFER                            \
  384.     { char *old_buffer = bufp->buffer;                    \
  385. !     if (bufp->allocated == (1L<<16)) goto too_big;            \
  386.       bufp->allocated *= 2;                        \
  387. !     if (bufp->allocated > (1L<<16)) bufp->allocated = (1L<<16);        \
  388. !     bufp->buffer = (char *) realloc (bufp->buffer, bufp->allocated);    \
  389.       if (bufp->buffer == 0)                        \
  390.         goto memory_exhausted;                        \
  391.       b = (b - old_buffer) + bufp->buffer;                \
  392. ***************
  393. *** 717,723 ****
  394.           case '[':
  395.             if (p == pend)
  396.               goto invalid_pattern;
  397. !       while (PTR_DIFF (b , bufp->buffer)
  398.            > bufp->allocated - 3 - (1 << BYTEWIDTH) / BYTEWIDTH)
  399.           EXTEND_BUFFER;
  400.   
  401. --- 633,639 ----
  402.           case '[':
  403.             if (p == pend)
  404.               goto invalid_pattern;
  405. !       while (b - bufp->buffer
  406.            > bufp->allocated - 3 - (1 << BYTEWIDTH) / BYTEWIDTH)
  407.           EXTEND_BUFFER;
  408.   
  409. ***************
  410. *** 802,808 ****
  411.                 if (c == ':' || c == ']' || p == pend
  412.                             || c1 == CHAR_CLASS_MAX_LENGTH)
  413.                   break;
  414. !               str[c1++] = (char) c;
  415.               }
  416.             str[c1] = '\0';
  417.             if (p == pend     
  418. --- 718,724 ----
  419.                 if (c == ':' || c == ']' || p == pend
  420.                             || c1 == CHAR_CLASS_MAX_LENGTH)
  421.                   break;
  422. !               str[c1++] = c;
  423.               }
  424.             str[c1] = '\0';
  425.             if (p == pend     
  426. ***************
  427. *** 1387,1393 ****
  428.        struct re_pattern_buffer *bufp;
  429.   {
  430.     unsigned char *pattern = (unsigned char *) bufp->buffer;
  431. !   LONG size = bufp->used;
  432.     register char *fastmap = bufp->fastmap;
  433.     register unsigned char *p = pattern;
  434.     register unsigned char *pend = pattern + size;
  435. --- 1303,1309 ----
  436.        struct re_pattern_buffer *bufp;
  437.   {
  438.     unsigned char *pattern = (unsigned char *) bufp->buffer;
  439. !   int size = bufp->used;
  440.     register char *fastmap = bufp->fastmap;
  441.     register unsigned char *p = pattern;
  442.     register unsigned char *pend = pattern + size;
  443. ***************
  444. *** 1813,1819 ****
  445.           stackx = (unsigned char **) alloca (2 * MAX_NUM_FAILURE_ITEMS    \
  446.                               * (stacke - stackb)        \
  447.                                               * sizeof (unsigned char *));\
  448. -     TEST_ALLOCA (stackx);                        \
  449.       /* Only copy what is in use.  */                \
  450.           bcopy (stackb, stackx, (stackp - stackb) * sizeof (char *));    \
  451.       stackp = stackx + (stackp - stackb);                \
  452. --- 1729,1734 ----
  453. ***************
  454. *** 2348,2355 ****
  455.           register unsigned char *p1 = p + mcnt;
  456.           /* p1[0] ... p1[2] are an on_failure_jump.
  457.              Examine what follows that.  */
  458. !         if (p1[3] == (unsigned char) exactn
  459. !             && p1[5] != (unsigned char) c)
  460.             p[-3] = (unsigned char) finalize_jump;
  461.           else if (p1[3] == (unsigned char) charset
  462.                || p1[3] == (unsigned char) charset_not)
  463. --- 2263,2269 ----
  464.           register unsigned char *p1 = p + mcnt;
  465.           /* p1[0] ... p1[2] are an on_failure_jump.
  466.              Examine what follows that.  */
  467. !         if (p1[3] == (unsigned char) exactn && p1[5] != c)
  468.             p[-3] = (unsigned char) finalize_jump;
  469.           else if (p1[3] == (unsigned char) charset
  470.                || p1[3] == (unsigned char) charset_not)
  471. ***************
  472. *** 2765,2775 ****
  473.   
  474.     /* Allow a command argument to specify the style of syntax.  */
  475.     if (argc > 1)
  476. - #ifdef MSDOS
  477. -     obscure_syntax = atol (argv[1]);
  478. - #else /* not MSDOS */    
  479.       obscure_syntax = atoi (argv[1]);
  480. - #endif /* not MSDOS */        
  481.   
  482.     buf.allocated = 40;
  483.     buf.buffer = (char *) malloc (buf.allocated);
  484. --- 2679,2685 ----
  485. diff -c DOS/regex.h GNU/regex.h
  486. *** DOS/regex.h    Thu Sep 20 00:19:10 1990
  487. --- GNU/regex.h    Thu Sep 20 00:19:56 1990
  488. ***************
  489. *** 16,40 ****
  490.      along with this program; if not, write to the Free Software
  491.      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  492.   
  493. - /* MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  494. -    This port is distributed under the terms of the GNU General
  495. -    Public License as published by the Free Software Foundation.
  496.   
  497. -    $Header: e:/gnu/lib/RCS/regex.h 1.1.0.1 90/09/11 09:24:51 tho Exp $
  498. -  */
  499. - 
  500.   #ifdef __GNUC__
  501.     #pragma once
  502.   #endif
  503.   
  504. - #ifdef MSDOS
  505. - #define LONG long
  506. - #define ONE 1L
  507. - #else /* not MSDOS */
  508. - #define LONG int
  509. - #define ONE 1
  510. - #endif /* not MSDOS */
  511. - 
  512.   #ifndef __REGEXP_LIBRARY
  513.   #define __REGEXP_LIBRARY
  514.   
  515. --- 16,26 ----
  516. ***************
  517. *** 52,58 ****
  518.   
  519.   
  520.   /* This defines the various regexp syntaxes.  */
  521. ! extern LONG obscure_syntax;
  522.   
  523.   
  524.   /* The following bits are used in the obscure_syntax variable to choose among
  525. --- 38,44 ----
  526.   
  527.   
  528.   /* This defines the various regexp syntaxes.  */
  529. ! extern int obscure_syntax;
  530.   
  531.   
  532.   /* The following bits are used in the obscure_syntax variable to choose among
  533. ***************
  534. *** 62,86 ****
  535.        parentheses are needed for literal searching.
  536.      If not set, backslash-parentheses are grouping, and plain parentheses
  537.        are for literal searching.  */
  538. ! #define RE_NO_BK_PARENS    ONE
  539.   
  540.   /* If this bit is set, plain | serves as the `or'-operator, and \| is a 
  541.        literal.
  542.      If not set, \| serves as the `or'-operator, and | is a literal.  */
  543. ! #define RE_NO_BK_VBAR (ONE << 1)
  544.   
  545.   /* If this bit is not set, plain + or ? serves as an operator, and \+, \? are 
  546.        literals.
  547.      If set, \+, \? are operators and plain +, ? are literals.  */
  548. ! #define RE_BK_PLUS_QM (ONE << 2)
  549.   
  550.   /* If this bit is set, | binds tighter than ^ or $.
  551.      If not set, the contrary.  */
  552. ! #define RE_TIGHT_VBAR (ONE << 3)
  553.   
  554.   /* If this bit is set, then treat newline as an OR operator.
  555.      If not set, treat it as a normal character.  */
  556. ! #define RE_NEWLINE_OR (ONE << 4)
  557.   
  558.   /* If this bit is set, then special characters may act as normal
  559.      characters in some contexts. Specifically, this applies to:
  560. --- 48,72 ----
  561.        parentheses are needed for literal searching.
  562.      If not set, backslash-parentheses are grouping, and plain parentheses
  563.        are for literal searching.  */
  564. ! #define RE_NO_BK_PARENS    1
  565.   
  566.   /* If this bit is set, plain | serves as the `or'-operator, and \| is a 
  567.        literal.
  568.      If not set, \| serves as the `or'-operator, and | is a literal.  */
  569. ! #define RE_NO_BK_VBAR (1 << 1)
  570.   
  571.   /* If this bit is not set, plain + or ? serves as an operator, and \+, \? are 
  572.        literals.
  573.      If set, \+, \? are operators and plain +, ? are literals.  */
  574. ! #define RE_BK_PLUS_QM (1 << 2)
  575.   
  576.   /* If this bit is set, | binds tighter than ^ or $.
  577.      If not set, the contrary.  */
  578. ! #define RE_TIGHT_VBAR (1 << 3)
  579.   
  580.   /* If this bit is set, then treat newline as an OR operator.
  581.      If not set, treat it as a normal character.  */
  582. ! #define RE_NEWLINE_OR (1 << 4)
  583.   
  584.   /* If this bit is set, then special characters may act as normal
  585.      characters in some contexts. Specifically, this applies to:
  586. ***************
  587. *** 90,139 ****
  588.      If this bit is not set, special characters (such as *, ^, and $)
  589.      always have their special meaning regardless of the surrounding
  590.      context.  */
  591. ! #define RE_CONTEXT_INDEP_OPS (ONE << 5)
  592.   
  593.   /* If this bit is not set, then \ before anything inside [ and ] is taken as 
  594.        a real \.
  595.      If set, then such a \ escapes the following character.  This is a
  596.        special case for awk.  */
  597. ! #define RE_AWK_CLASS_HACK (ONE << 6)
  598.   
  599.   /* If this bit is set, then \{ and \} or { and } serve as interval operators.
  600.      If not set, then \{ and \} and { and } are treated as literals.  */
  601. ! #define RE_INTERVALS (ONE << 7)
  602.   
  603.   /* If this bit is not set, then \{ and \} serve as interval operators and 
  604.        { and } are literals.
  605.      If set, then { and } serve as interval operators and \{ and \} are 
  606.        literals.  */
  607. ! #define RE_NO_BK_CURLY_BRACES (ONE << 8)
  608.   
  609.   /* If this bit is set, then character classes are supported; they are:
  610.        [:alpha:],    [:upper:], [:lower:],  [:digit:], [:alnum:], [:xdigit:],
  611.        [:space:], [:print:], [:punct:], [:graph:], and [:cntrl:].
  612.      If not set, then character classes are not supported.  */
  613. ! #define RE_CHAR_CLASSES (ONE << 9)
  614.   
  615.   /* If this bit is set, then the dot re doesn't match a null byte.
  616.      If not set, it does.  */
  617. ! #define RE_DOT_NOT_NULL (ONE << 10)
  618.   
  619.   /* If this bit is set, then [^...] doesn't match a newline.
  620.      If not set, it does.  */
  621. ! #define RE_HAT_NOT_NEWLINE (ONE << 11)
  622.   
  623.   /* If this bit is set, back references are recognized.
  624.      If not set, they aren't.  */
  625. ! #define RE_NO_BK_REFS (ONE << 12)
  626.   
  627.   /* If this bit is set, back references must refer to a preceding
  628.      subexpression.  If not set, a back reference to a nonexistent
  629.      subexpression is treated as literal characters.  */
  630. ! #define RE_NO_EMPTY_BK_REF (ONE << 13)
  631.   
  632.   /* If this bit is set, bracket expressions can't be empty.  
  633.      If it is set, they can be empty.  */
  634. ! #define RE_NO_EMPTY_BRACKETS (ONE << 14)
  635.   
  636.   /* If this bit is set, then *, +, ? and { cannot be first in an re or
  637.      immediately after a |, or a (.  Furthermore, a | cannot be first or
  638. --- 76,125 ----
  639.      If this bit is not set, special characters (such as *, ^, and $)
  640.      always have their special meaning regardless of the surrounding
  641.      context.  */
  642. ! #define RE_CONTEXT_INDEP_OPS (1 << 5)
  643.   
  644.   /* If this bit is not set, then \ before anything inside [ and ] is taken as 
  645.        a real \.
  646.      If set, then such a \ escapes the following character.  This is a
  647.        special case for awk.  */
  648. ! #define RE_AWK_CLASS_HACK (1 << 6)
  649.   
  650.   /* If this bit is set, then \{ and \} or { and } serve as interval operators.
  651.      If not set, then \{ and \} and { and } are treated as literals.  */
  652. ! #define RE_INTERVALS (1 << 7)
  653.   
  654.   /* If this bit is not set, then \{ and \} serve as interval operators and 
  655.        { and } are literals.
  656.      If set, then { and } serve as interval operators and \{ and \} are 
  657.        literals.  */
  658. ! #define RE_NO_BK_CURLY_BRACES (1 << 8)
  659.   
  660.   /* If this bit is set, then character classes are supported; they are:
  661.        [:alpha:],    [:upper:], [:lower:],  [:digit:], [:alnum:], [:xdigit:],
  662.        [:space:], [:print:], [:punct:], [:graph:], and [:cntrl:].
  663.      If not set, then character classes are not supported.  */
  664. ! #define RE_CHAR_CLASSES (1 << 9)
  665.   
  666.   /* If this bit is set, then the dot re doesn't match a null byte.
  667.      If not set, it does.  */
  668. ! #define RE_DOT_NOT_NULL (1 << 10)
  669.   
  670.   /* If this bit is set, then [^...] doesn't match a newline.
  671.      If not set, it does.  */
  672. ! #define RE_HAT_NOT_NEWLINE (1 << 11)
  673.   
  674.   /* If this bit is set, back references are recognized.
  675.      If not set, they aren't.  */
  676. ! #define RE_NO_BK_REFS (1 << 12)
  677.   
  678.   /* If this bit is set, back references must refer to a preceding
  679.      subexpression.  If not set, a back reference to a nonexistent
  680.      subexpression is treated as literal characters.  */
  681. ! #define RE_NO_EMPTY_BK_REF (1 << 13)
  682.   
  683.   /* If this bit is set, bracket expressions can't be empty.  
  684.      If it is set, they can be empty.  */
  685. ! #define RE_NO_EMPTY_BRACKETS (1 << 14)
  686.   
  687.   /* If this bit is set, then *, +, ? and { cannot be first in an re or
  688.      immediately after a |, or a (.  Furthermore, a | cannot be first or
  689. ***************
  690. *** 140,160 ****
  691.      last in an re, or immediately follow another | or a (.  Also, a ^
  692.      cannot appear in a nonleading position and a $ cannot appear in a
  693.      nontrailing position (outside of bracket expressions, that is).  */
  694. ! #define RE_CONTEXTUAL_INVALID_OPS (ONE << 15)
  695.   
  696.   /* If this bit is set, then +, ? and | aren't recognized as operators.
  697.      If it's not, they are.  */
  698. ! #define RE_LIMITED_OPS (ONE << 16)
  699.   
  700.   /* If this bit is set, then an ending range point has to collate higher
  701.        or equal to the starting range point.
  702.      If it's not set, then when the ending range point collates higher
  703.        than the starting range point, the range is just considered empty.  */
  704. ! #define RE_NO_EMPTY_RANGES (ONE << 17)
  705.   
  706.   /* If this bit is set, then a hyphen (-) can't be an ending range point.
  707.      If it isn't, then it can.  */
  708. ! #define RE_NO_HYPHEN_RANGE_END (ONE << 18)
  709.   
  710.   
  711.   /* Define combinations of bits for the standard possibilities.  */
  712. --- 126,146 ----
  713.      last in an re, or immediately follow another | or a (.  Also, a ^
  714.      cannot appear in a nonleading position and a $ cannot appear in a
  715.      nontrailing position (outside of bracket expressions, that is).  */
  716. ! #define RE_CONTEXTUAL_INVALID_OPS (1 << 15)
  717.   
  718.   /* If this bit is set, then +, ? and | aren't recognized as operators.
  719.      If it's not, they are.  */
  720. ! #define RE_LIMITED_OPS (1 << 16)
  721.   
  722.   /* If this bit is set, then an ending range point has to collate higher
  723.        or equal to the starting range point.
  724.      If it's not set, then when the ending range point collates higher
  725.        than the starting range point, the range is just considered empty.  */
  726. ! #define RE_NO_EMPTY_RANGES (1 << 17)
  727.   
  728.   /* If this bit is set, then a hyphen (-) can't be an ending range point.
  729.      If it isn't, then it can.  */
  730. ! #define RE_NO_HYPHEN_RANGE_END (1 << 18)
  731.   
  732.   
  733.   /* Define combinations of bits for the standard possibilities.  */
  734. ***************
  735. *** 248,256 ****
  736.   /* 4.2 bsd compatibility.  */
  737.   extern char *re_comp (char *);
  738.   extern int re_exec (char *);
  739. - 
  740. - /* for GNU grep [tho] */
  741. - extern    LONG re_set_syntax (LONG syntax);
  742.   
  743.   #else /* !__STDC__ */
  744.   
  745. --- 234,239 ----
  746.